package main

import (
	"fmt"
	"net/http"
	"os"
	"reflect"
	"runtime"
	"time"
)

//
//import (
//	"bufio"
//	. "common"
//	"core"
//	"leaf/core/cluster"
//	"leaf/core/log"
//	"leaf/core/msg"
//	"leaf/core/network"
//	"leaf/core/rpc"
//	. "leaf/core/time"
//	"leaf/core/tool"
//	"fmt"
//	"net"
//	"os"
//	"os/signal"
//	"leaf/pb"
//	"strings"
//	"syscall"
//	"time"
//)
//
//func server() {
//	//   simple tcp server
//	//1.listen ip+port
//	listener, err := net.Listen("tcp", "0.0.0.0:9090")
//	if err != nil {
//		fmt.Printf("listen fail, err: %v\n", err)
//		return
//	}
//
//	//2.accept client request
//	//3.create goroutine for each request
//	for {
//		conn, err := listener.Accept()
//		if err != nil {
//			fmt.Printf("accept fail, err: %v\n", err)
//			continue
//		}
//
//		//create goroutine for each connect
//		go process(conn)
//
//		Sleep(20 * 1000)
//		conn.SetReadDeadline(time.Now())
//	}
//}
//
//func process(conn net.Conn) {
//	defer conn.Close()
//	for {
//		var buf [128]byte
//		n, err := conn.Read(buf[:])
//
//		if err != nil {
//			fmt.Printf("read from connect failed, err: %v\n", err)
//			break
//		}
//		str := string(buf[:n])
//		fmt.Printf("receive from client, data: %v\n", str)
//	}
//}
//
//func client() {
//	conn, err := net.Dial("tcp", "192.168.9.106:8888")
//	if err != nil {
//		fmt.Printf("connect failed, err : %v\n", err.Error())
//		return
//	}
//	defer conn.Close()
//
//	inputReader := bufio.NewReader(os.Stdin)
//
//	for {
//		input, err := inputReader.ReadString('\n')
//		if err != nil {
//			fmt.Printf("read from console failed, err: %v\n", err)
//			break
//		}
//		trimmedInput := strings.TrimSpace(input)
//		if trimmedInput == "Q" {
//			break
//		}
//		_, err = conn.Write([]byte(trimmedInput))
//
//		if err != nil {
//			fmt.Printf("write failed , err : %v\n", err)
//			break
//		}
//	}
//}
//
//func test() {
//	var rpcClient = rpc.NewRpcClient("logic", nil)
//	rpcClient.Conn = network.NewTcpConn("127.0.0.1:3001", nil, rpcClient)
//	if rpcClient.Conn == nil {
//		log.Fatal("RpcConnect err:rpc conn is nil")
//	}
//	rpcClient.Conn.Start()
//	pmsg := msg.NewRpcMessage("GetLogicAddr", 0, nil)
//	rpcClient.SendMsg(pmsg)
//	c := make(chan os.Signal, 1)
//	signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGINT)
//	sig := <-c
//	log.Release("closing down signal: %v", sig)
//	tool.GoClose()
//	tool.GoWait()
//}
//
//func clusterTest() {
//	closer := core.Init("bin/conf/auth_1001.json", SRV_RPC_MAP[ServType_Auth])
//	if closer != nil {
//		defer closer()
//	}
//
//	cluster.Init()
//	// cluster
//	cluster.Start()
//	Sleep(1000)
//	logicNode := cluster.GetBestNode(ServType_Logic)
//	if logicNode == nil {
//		log.Release("LoginUseRoleHandler err:%v", Error_NoneLogicNode)
//	} else {
//
//		var gateAddr = &pb.S2C_GateAddr{}
//		if err := logicNode.Call("GetLogicAddr", nil, gateAddr); IsError(err) {
//			log.Release("GetLogicAddr err:%v", err)
//		} else {
//			log.Release("GetLogicAddr res:%v", gateAddr)
//		}
//	}
//	c := make(chan os.Signal, 1)
//	signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGINT)
//	sig := <-c
//	log.Release("closing down signal: %v", sig)
//	cluster.Destroy()
//
//	tool.GoClose()
//	tool.GoWait()
//}

func nowStats() {
	var ms runtime.MemStats
	runtime.ReadMemStats(&ms)
	fmt.Printf("Alloc:%d(bytes) HeapIdle:%d(bytes) HeapReleased:%d(bytes) NumGoroutine:%d \n", ms.Alloc, ms.HeapIdle, ms.HeapReleased, runtime.NumGoroutine())
}

func main() {
	// 开启pprof
	go func() {
		ip := "0.0.0.0:6060"
		if err := http.ListenAndServe(ip, nil); err != nil {
			fmt.Printf("start pprof failed on %s\n", ip)
			os.Exit(1)
		}
	}()

	tick := time.Tick(time.Second / 100)
	var buf []byte
	for range tick {
		buf = append(buf, make([]byte, 1024*1024)...)
	}

	fmt.Printf("%v", reflect.TypeOf(tick).Kind())
}
